ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ನಿಖರ ಪ್ರಕಾರಗಳು: ದೃಢವಾದ ಕೋಡ್‌ಗಾಗಿ ಕಟ್ಟುನಿಟ್ಟಾದ ಆಬ್ಜೆಕ್ಟ್ ಆಕಾರ ಹೊಂದಾಣಿಕೆ

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಒಂದು ಸೂಪರ್‌ಸೆಟ್, ವೆಬ್ ಅಭಿವೃದ್ಧಿಯ ಕ್ರಿಯಾತ್ಮಕ ಜಗತ್ತಿಗೆ ಸ್ಟ್ಯಾಟಿಕ್ ಟೈಪಿಂಗ್ ಅನ್ನು ತರುತ್ತದೆ. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಟೈಪ್ ಸುರಕ್ಷತೆ ಮತ್ತು ಕೋಡ್ ನಿರ್ವಹಣೆಯ ವಿಷಯದಲ್ಲಿ ಗಮನಾರ್ಹ ಪ್ರಯೋಜನಗಳನ್ನು ನೀಡುತ್ತದೆಯಾದರೂ, ಅದರ ರಚನಾತ್ಮಕ ಟೈಪಿಂಗ್ ವ್ಯವಸ್ಥೆಯು ಕೆಲವೊಮ್ಮೆ ಅನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆಗೆ ಕಾರಣವಾಗಬಹುದು. ಇಲ್ಲಿಯೇ "ನಿಖರ ಪ್ರಕಾರಗಳು" (exact types) ಎಂಬ ಪರಿಕಲ್ಪನೆಯು ಕಾರ್ಯರೂಪಕ್ಕೆ ಬರುತ್ತದೆ. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ "ನಿಖರ ಪ್ರಕಾರಗಳು" ಎಂದು ಸ್ಪಷ್ಟವಾಗಿ ಹೆಸರಿಸಲಾದ ಅಂತರ್ನಿರ್ಮಿತ ವೈಶಿಷ್ಟ್ಯವಿಲ್ಲದಿದ್ದರೂ, ನಾವು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ವೈಶಿಷ್ಟ್ಯಗಳು ಮತ್ತು ತಂತ್ರಗಳ ಸಂಯೋಜನೆಯ ಮೂಲಕ ಇದೇ ರೀತಿಯ ನಡವಳಿಕೆಯನ್ನು ಸಾಧಿಸಬಹುದು. ಈ ಬ್ಲಾಗ್ ಪೋಸ್ಟ್ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಕಟ್ಟುನಿಟ್ಟಾದ ಆಬ್ಜೆಕ್ಟ್ ಆಕಾರ ಹೊಂದಾಣಿಕೆಯನ್ನು ಹೇಗೆ ಜಾರಿಗೊಳಿಸುವುದು ಎಂಬುದರ ಕುರಿತು ಚರ್ಚಿಸುತ್ತದೆ, ಇದರಿಂದ ಕೋಡ್ ದೃಢತೆಯನ್ನು ಸುಧಾರಿಸಬಹುದು ಮತ್ತು ಸಾಮಾನ್ಯ ದೋಷಗಳನ್ನು ತಡೆಯಬಹುದು.

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ರಚನಾತ್ಮಕ ಟೈಪಿಂಗ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ರಚನಾತ್ಮಕ ಟೈಪಿಂಗ್ (ಡಕ್ ಟೈಪಿಂಗ್ ಎಂದೂ ಕರೆಯಲ್ಪಡುತ್ತದೆ) ಅನ್ನು ಬಳಸುತ್ತದೆ, ಅಂದರೆ ಪ್ರಕಾರದ ಹೊಂದಾಣಿಕೆಯನ್ನು ಪ್ರಕಾರಗಳ ಸದಸ್ಯರಿಂದ ನಿರ್ಧರಿಸಲಾಗುತ್ತದೆ, ಅವುಗಳ ಘೋಷಿತ ಹೆಸರುಗಳಿಂದಲ್ಲ. ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಒಂದು ಪ್ರಕಾರಕ್ಕೆ ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊಂದಿದ್ದರೆ, ಅದು ಹೆಚ್ಚುವರಿ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊಂದಿದ್ದರೂ ಸಹ, ಆ ಪ್ರಕಾರದೊಂದಿಗೆ ಹೊಂದಾಣಿಕೆಯಾಗುತ್ತದೆ ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ.

ಉದಾಹರಣೆಗೆ:

interface Point {
  x: number;
  y: number;
}

const myPoint = { x: 10, y: 20, z: 30 };

function printPoint(point: Point) {
  console.log(`X: ${point.x}, Y: ${point.y}`);
}

printPoint(myPoint); // ಇದು ಸರಿಯಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ, myPoint ನಲ್ಲಿ 'z' ಪ್ರಾಪರ್ಟಿ ಇದ್ದರೂ ಸಹ

ಈ ಸನ್ನಿವೇಶದಲ್ಲಿ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ `myPoint` ಅನ್ನು `printPoint` ಗೆ ರವಾನಿಸಲು ಅನುಮತಿಸುತ್ತದೆ, ಏಕೆಂದರೆ ಇದು ಅಗತ್ಯವಿರುವ `x` ಮತ್ತು `y` ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊಂದಿದೆ, ಆದರೂ ಇದರಲ್ಲಿ ಹೆಚ್ಚುವರಿ `z` ಪ್ರಾಪರ್ಟಿ ಇದೆ. ಈ ನಮ್ಯತೆಯು ಅನುಕೂಲಕರವಾಗಿದ್ದರೂ, ನೀವು ಅನಿರೀಕ್ಷಿತವಾಗಿ ಹೆಚ್ಚುವರಿ ಪ್ರಾಪರ್ಟಿಗಳೊಂದಿಗೆ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರವಾನಿಸಿದರೆ ಸೂಕ್ಷ್ಮ ದೋಷಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.

ಹೆಚ್ಚುವರಿ ಪ್ರಾಪರ್ಟಿಗಳೊಂದಿಗೆ ಇರುವ ಸಮಸ್ಯೆ

ರಚನಾತ್ಮಕ ಟೈಪಿಂಗ್‌ನ ಈ ಮೃದುತ್ವವು ಕೆಲವೊಮ್ಮೆ ದೋಷಗಳನ್ನು ಮರೆಮಾಡಬಹುದು. ಕಾನ್ಫಿಗರೇಶನ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ನಿರೀಕ್ಷಿಸುವ ಫಂಕ್ಷನ್ ಅನ್ನು ಪರಿಗಣಿಸಿ:

interface Config {
  apiUrl: string;
  timeout: number;
}

function setup(config: Config) {
  console.log(`API URL: ${config.apiUrl}`);
  console.log(`Timeout: ${config.timeout}`);
}

const myConfig = { apiUrl: "https://api.example.com", timeout: 5000, typo: true };

setup(myConfig); // ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಇಲ್ಲಿ ದೂರುವುದಿಲ್ಲ!

console.log(myConfig.typo); //true ಎಂದು ಮುದ್ರಿಸುತ್ತದೆ. ಹೆಚ್ಚುವರಿ ಪ್ರಾಪರ್ಟಿ ಮೌನವಾಗಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, `myConfig` ನಲ್ಲಿ ಹೆಚ್ಚುವರಿ ಪ್ರಾಪರ್ಟಿ `typo` ಇದೆ. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ದೋಷವನ್ನು ನೀಡುವುದಿಲ್ಲ ಏಕೆಂದರೆ `myConfig` ಇನ್ನೂ `Config` ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಪೂರೈಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಈ ಮುದ್ರಣದೋಷವು ಎಂದಿಗೂ ಪತ್ತೆಯಾಗುವುದಿಲ್ಲ, ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ನಿರೀಕ್ಷೆಯಂತೆ ವರ್ತಿಸದಿರಬಹುದು. ಸಂಕೀರ್ಣ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಡೀಬಗ್ ಮಾಡುವಾಗ ಈ ರೀತಿಯ ಸಣ್ಣ ಸಮಸ್ಯೆಗಳು ದೊಡ್ಡ ತಲೆನೋವಾಗಿ ಬೆಳೆಯಬಹುದು. ಆಬ್ಜೆಕ್ಟ್‌ಗಳೊಳಗೆ ನೆಸ್ಟ್ ಮಾಡಲಾದ ಆಬ್ಜೆಕ್ಟ್‌ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಕಾಣೆಯಾದ ಅಥವಾ ತಪ್ಪಾಗಿ ಬರೆಯಲಾದ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಪತ್ತೆಹಚ್ಚುವುದು ವಿಶೇಷವಾಗಿ ಕಷ್ಟಕರವಾಗಿರುತ್ತದೆ.

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ನಿಖರ ಪ್ರಕಾರಗಳನ್ನು ಜಾರಿಗೊಳಿಸುವ ವಿಧಾನಗಳು

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ನಿಜವಾದ "ನಿಖರ ಪ್ರಕಾರಗಳು" ನೇರವಾಗಿ ಲಭ್ಯವಿಲ್ಲದಿದ್ದರೂ, ಇದೇ ರೀತಿಯ ಫಲಿತಾಂಶಗಳನ್ನು ಸಾಧಿಸಲು ಮತ್ತು ಕಟ್ಟುನಿಟ್ಟಾದ ಆಬ್ಜೆಕ್ಟ್ ಆಕಾರ ಹೊಂದಾಣಿಕೆಯನ್ನು ಜಾರಿಗೊಳಿಸಲು ಹಲವಾರು ತಂತ್ರಗಳಿವೆ:

1. `Omit` ಜೊತೆಗೆ ಟೈಪ್ ಅಸರ್ಷನ್‌ಗಳನ್ನು ಬಳಸುವುದು

`Omit` ಯುಟಿಲಿಟಿ ಪ್ರಕಾರವು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪ್ರಕಾರದಿಂದ ಕೆಲವು ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊರತುಪಡಿಸಿ ಹೊಸ ಪ್ರಕಾರವನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಟೈಪ್ ಅಸರ್ಷನ್‌ನೊಂದಿಗೆ ಸಂಯೋಜಿಸಿದಾಗ, ಇದು ಹೆಚ್ಚುವರಿ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ತಡೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

interface Point {
  x: number;
  y: number;
}

const myPoint = { x: 10, y: 20, z: 30 };

// Point ನ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಮಾತ್ರ ಒಳಗೊಂಡಿರುವ ಒಂದು ಪ್ರಕಾರವನ್ನು ರಚಿಸಿ
const exactPoint: Point = myPoint as Omit & Point;

// Error: Type '{ x: number; y: number; z: number; }' is not assignable to type 'Point'.
// Object literal may only specify known properties, and 'z' does not exist in type 'Point'.

function printPoint(point: Point) {
  console.log(`X: ${point.x}, Y: ${point.y}`);
}


//Fix
const myPointCorrect = { x: 10, y: 20 };
const exactPointCorrect: Point = myPointCorrect as Omit & Point;
printPoint(exactPointCorrect);

ಈ ವಿಧಾನವು `myPoint` ನಲ್ಲಿ `Point` ಇಂಟರ್ಫೇಸ್‌ನಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸದ ಪ್ರಾಪರ್ಟಿಗಳು ಇದ್ದರೆ ದೋಷವನ್ನು ನೀಡುತ್ತದೆ.

ವಿವರಣೆ: `Omit` ಎಂಬುದು `myPoint` ಪ್ರಕಾರದಿಂದ `Point` ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಕೀಗಳನ್ನು ತೆಗೆದುಹಾಕುವ ಒಂದು ಪ್ರಕಾರವನ್ನು ರಚಿಸುತ್ತದೆ. ನಂತರ `& Point` ಈ ಪ್ರಕಾರವನ್ನು `Point` ಪ್ರಕಾರದೊಂದಿಗೆ ಸಂಯೋಜಿಸುತ್ತದೆ, ಆಬ್ಜೆಕ್ಟ್ `Point` ಪ್ರಕಾರಕ್ಕೆ ಅನುಗುಣವಾಗಿರಬೇಕು ಎಂದು ಒತ್ತಾಯಿಸುತ್ತದೆ. ಈ ಸಂಯೋಜಿತ ಪ್ರಕಾರಕ್ಕೆ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಅಸರ್ಟ್ ಮಾಡುವುದರಿಂದ, ಕಂಪೈಲರ್ ಹೆಚ್ಚುವರಿ ಪ್ರಾಪರ್ಟಿಗಳಿಗಾಗಿ ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಯಾವುದಾದರೂ ಕಂಡುಬಂದಲ್ಲಿ ದೋಷವನ್ನು ನೀಡುತ್ತದೆ. ಇದು ನಮ್ಮ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಆರಂಭದಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸುವಾಗ ಸರಿಯಾದ ಆಕಾರವನ್ನು ಘೋಷಿಸಲು ನಮ್ಮನ್ನು ಒತ್ತಾಯಿಸುತ್ತದೆ.

2. ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸಲು ಫಂಕ್ಷನ್ ಬಳಸುವುದು

ಇಂಟರ್ಫೇಸ್‌ನಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಮಾತ್ರ ಸ್ವೀಕರಿಸುವ ಫ್ಯಾಕ್ಟರಿ ಫಂಕ್ಷನ್ ಅನ್ನು ನೀವು ರಚಿಸಬಹುದು. ಈ ವಿಧಾನವು ಆಬ್ಜೆಕ್ಟ್ ರಚನೆಯ ಹಂತದಲ್ಲಿ ಬಲವಾದ ಟೈಪ್ ಪರಿಶೀಲನೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.

interface Config {
  apiUrl: string;
  timeout: number;
}

function createConfig(config: Config): Config {
  return {
    apiUrl: config.apiUrl,
    timeout: config.timeout,
  };
}

const myConfig = createConfig({ apiUrl: "https://api.example.com", timeout: 5000 });

//This will not compile:
//const myConfigError = createConfig({ apiUrl: "https://api.example.com", timeout: 5000, typo: true });
//Argument of type '{ apiUrl: string; timeout: number; typo: true; }' is not assignable to parameter of type 'Config'.
// Object literal may only specify known properties, and 'typo' does not exist in type 'Config'.

`Config` ಇಂಟರ್ಫೇಸ್‌ನಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಪ್ರಾಪರ್ಟಿಗಳೊಂದಿಗೆ ಮಾತ್ರ ನಿರ್ಮಿಸಲಾದ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುವ ಮೂಲಕ, ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಪ್ರಾಪರ್ಟಿಗಳು ಸೇರಿಕೊಳ್ಳುವುದಿಲ್ಲ ಎಂದು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುತ್ತೀರಿ. ಇದು ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ರಚಿಸಲು ಸುರಕ್ಷಿತವಾಗಿಸುತ್ತದೆ.

3. ಟೈಪ್ ಗಾರ್ಡ್‌ಗಳನ್ನು ಬಳಸುವುದು

ಟೈಪ್ ಗಾರ್ಡ್‌ಗಳು ಒಂದು ನಿರ್ದಿಷ್ಟ ವ್ಯಾಪ್ತಿಯೊಳಗೆ ವೇರಿಯಬಲ್‌ನ ಪ್ರಕಾರವನ್ನು ಸಂಕುಚಿತಗೊಳಿಸುವ ಫಂಕ್ಷನ್‌ಗಳಾಗಿವೆ. ಅವು ನೇರವಾಗಿ ಹೆಚ್ಚುವರಿ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ತಡೆಯದಿದ್ದರೂ, ಅವುಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಪರಿಶೀಲಿಸಲು ಮತ್ತು ಸೂಕ್ತ ಕ್ರಮ ತೆಗೆದುಕೊಳ್ಳಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತವೆ.

interface User {
  id: number;
  name: string;
}

function isUser(obj: any): obj is User {
  return (
    typeof obj === 'object' &&
    obj !== null &&
    'id' in obj && typeof obj.id === 'number' &&
    'name' in obj && typeof obj.name === 'string' &&
    Object.keys(obj).length === 2 //ಕೀಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪರಿಶೀಲಿಸಿ. ಗಮನಿಸಿ: ಇದು User ನ ನಿಖರವಾದ ಕೀಗಳ ಸಂಖ್ಯೆಯನ್ನು ಅವಲಂಬಿಸಿದೆ.
  );
}

const potentialUser1 = { id: 123, name: "Alice" };
const potentialUser2 = { id: 456, name: "Bob", extra: true };

if (isUser(potentialUser1)) {
  console.log("Valid User:", potentialUser1.name);
} else {
  console.log("Invalid User");
}

if (isUser(potentialUser2)) {
  console.log("Valid User:", potentialUser2.name); //ಇಲ್ಲಿ ತಲುಪುವುದಿಲ್ಲ
} else {
  console.log("Invalid User");
}

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, `isUser` ಟೈಪ್ ಗಾರ್ಡ್ ಅಗತ್ಯವಿರುವ ಪ್ರಾಪರ್ಟಿಗಳ ಇರುವಿಕೆಯನ್ನು ಮಾತ್ರವಲ್ಲದೆ ಅವುಗಳ ಪ್ರಕಾರಗಳನ್ನು ಮತ್ತು ಪ್ರಾಪರ್ಟಿಗಳ *ನಿಖರ* ಸಂಖ್ಯೆಯನ್ನು ಸಹ ಪರಿಶೀಲಿಸುತ್ತದೆ. ಈ ವಿಧಾನವು ಹೆಚ್ಚು ಸ್ಪಷ್ಟವಾಗಿದೆ ಮತ್ತು ಅಮಾನ್ಯ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಪ್ರಾಪರ್ಟಿಗಳ ಸಂಖ್ಯೆಯ ಪರಿಶೀಲನೆಯು ದುರ್ಬಲವಾಗಿರುತ್ತದೆ. `User` ಗೆ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಸೇರಿಸಿದಾಗ ಅಥವಾ ತೆಗೆದುಹಾಕಿದಾಗ, ಈ ಪರಿಶೀಲನೆಯನ್ನು ನವೀಕರಿಸಬೇಕು.

4. `Readonly` ಮತ್ತು `as const` ಅನ್ನು ಬಳಸಿಕೊಳ್ಳುವುದು

`Readonly` ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪ್ರಾಪರ್ಟಿಗಳ ಮಾರ್ಪಾಡನ್ನು ತಡೆಯುತ್ತದೆ, ಮತ್ತು `as const` ಒಂದು ರೀಡ್-ಓನ್ಲಿ ಟುಪಲ್ ಅಥವಾ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಅಲ್ಲಿ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳು ಆಳವಾಗಿ ರೀಡ್-ಓನ್ಲಿ ಮತ್ತು ಲಿಟರಲ್ ಪ್ರಕಾರಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ. ಇತರ ವಿಧಾನಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಿದಾಗ ಕಟ್ಟುನಿಟ್ಟಾದ ವ್ಯಾಖ್ಯಾನ ಮತ್ತು ಪ್ರಕಾರ ಪರಿಶೀಲನೆಯನ್ನು ರಚಿಸಲು ಇವುಗಳನ್ನು ಬಳಸಬಹುದು. ಆದಾಗ್ಯೂ, ಇವೆರಡೂ ಹೆಚ್ಚುವರಿ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ತಾವಾಗಿಯೇ ತಡೆಯುವುದಿಲ್ಲ.

interface Options {
  width: number;
  height: number;
}

//Create the Readonly type
type ReadonlyOptions = Readonly;

const options: ReadonlyOptions = { width: 100, height: 200 };

//options.width = 300; //error: Cannot assign to 'width' because it is a read-only property.

//Using as const
const config = { api_url: "https://example.com", timeout: 3000 } as const;

//config.timeout = 5000; //error: Cannot assign to 'timeout' because it is a read-only property.

//However, excess properties are still allowed:
const invalidOptions: ReadonlyOptions = { width: 100, height: 200, depth: 300 }; //no error. Still allows excess properties.


interface StrictOptions {
  readonly width: number;
  readonly height: number;
}

//This will now error:
//const invalidStrictOptions: StrictOptions = { width: 100, height: 200, depth: 300 };
//Type '{ width: number; height: number; depth: number; }' is not assignable to type 'StrictOptions'.
//  Object literal may only specify known properties, and 'depth' does not exist in type 'StrictOptions'.

ಇದು ಬದಲಾಯಿಸಲಾಗದ ಸ್ಥಿತಿಯನ್ನು (immutability) ಸುಧಾರಿಸುತ್ತದೆ, ಆದರೆ ಇದು ಕೇವಲ ಬದಲಾವಣೆಯನ್ನು ತಡೆಯುತ್ತದೆ, ಹೆಚ್ಚುವರಿ ಪ್ರಾಪರ್ಟಿಗಳ ಅಸ್ತಿತ್ವವನ್ನು ತಡೆಯುವುದಿಲ್ಲ. `Omit` ಅಥವಾ ಫಂಕ್ಷನ್ ವಿಧಾನದೊಂದಿಗೆ ಸಂಯೋಜಿಸಿದಾಗ ಇದು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗುತ್ತದೆ.

5. ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸುವುದು (ಉದಾಹರಣೆಗೆ, Zod, io-ts)

Zod ಮತ್ತು io-ts ನಂತಹ ಲೈಬ್ರರಿಗಳು ಶಕ್ತಿಯುತ ರನ್‌ಟೈಮ್ ಟೈಪ್ ಮೌಲ್ಯಮಾಪನ ಮತ್ತು ಸ್ಕೀಮಾ ವ್ಯಾಖ್ಯಾನ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ನೀಡುತ್ತವೆ. ಈ ಲೈಬ್ರರಿಗಳು ನಿಮ್ಮ ಡೇಟಾದ ನಿರೀಕ್ಷಿತ ಆಕಾರವನ್ನು ನಿಖರವಾಗಿ ವಿವರಿಸುವ ಸ್ಕೀಮಾಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತವೆ, ಇದರಲ್ಲಿ ಹೆಚ್ಚುವರಿ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ತಡೆಯುವುದು ಸಹ ಸೇರಿದೆ. ಅವು ರನ್‌ಟೈಮ್ ಅವಲಂಬನೆಯನ್ನು ಸೇರಿಸಿದರೂ, ಅವು ಅತ್ಯಂತ ದೃಢವಾದ ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳುವ ಪರಿಹಾರವನ್ನು ನೀಡುತ್ತವೆ.

Zod ಜೊತೆಗಿನ ಉದಾಹರಣೆ:

import { z } from 'zod';

const UserSchema = z.object({
  id: z.number(),
  name: z.string(),
});

type User = z.infer;

const validUser = { id: 1, name: "John" };
const invalidUser = { id: 2, name: "Jane", extra: true };

const parsedValidUser = UserSchema.parse(validUser);
console.log("Parsed Valid User:", parsedValidUser);

try {
  const parsedInvalidUser = UserSchema.parse(invalidUser);
  console.log("Parsed Invalid User:", parsedInvalidUser); // This won't be reached
} catch (error) {
  console.error("Validation Error:", error.errors);
}

Zod ನ `parse` ವಿಧಾನವು ಇನ್‌ಪುಟ್ ಸ್ಕೀಮಾಗೆ ಅನುಗುಣವಾಗಿರದಿದ್ದರೆ ದೋಷವನ್ನು ನೀಡುತ್ತದೆ, ಇದರಿಂದಾಗಿ ಹೆಚ್ಚುವರಿ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ತಡೆಯುತ್ತದೆ. ಇದು ರನ್‌ಟೈಮ್ ಮೌಲ್ಯಮಾಪನವನ್ನು ಒದಗಿಸುತ್ತದೆ ಮತ್ತು ಸ್ಕೀಮಾದಿಂದ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಕಾರಗಳನ್ನು ಸಹ ಉತ್ಪಾದಿಸುತ್ತದೆ, ನಿಮ್ಮ ಪ್ರಕಾರದ ವ್ಯಾಖ್ಯಾನಗಳು ಮತ್ತು ರನ್‌ಟೈಮ್ ಮೌಲ್ಯಮಾಪನ ತರ್ಕದ ನಡುವೆ ಸ್ಥಿರತೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ನಿಖರ ಪ್ರಕಾರಗಳನ್ನು ಜಾರಿಗೊಳಿಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಕಟ್ಟುನಿಟ್ಟಾದ ಆಬ್ಜೆಕ್ಟ್ ಆಕಾರ ಹೊಂದಾಣಿಕೆಯನ್ನು ಜಾರಿಗೊಳಿಸುವಾಗ ಪರಿಗಣಿಸಬೇಕಾದ ಕೆಲವು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು ಇಲ್ಲಿವೆ:

• ಸರಿಯಾದ ತಂತ್ರವನ್ನು ಆರಿಸಿ: ಅತ್ಯುತ್ತಮ ವಿಧಾನವು ನಿಮ್ಮ ನಿರ್ದಿಷ್ಟ ಅಗತ್ಯಗಳು ಮತ್ತು ಯೋಜನೆಯ ಅವಶ್ಯಕತೆಗಳನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಸರಳ ಸಂದರ್ಭಗಳಲ್ಲಿ, `Omit` ಜೊತೆಗೆ ಟೈಪ್ ಅಸರ್ಷನ್‌ಗಳು ಅಥವಾ ಫ್ಯಾಕ್ಟರಿ ಫಂಕ್ಷನ್‌ಗಳು ಸಾಕಾಗಬಹುದು. ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಸನ್ನಿವೇಶಗಳಿಗೆ ಅಥವಾ ರನ್‌ಟೈಮ್ ಮೌಲ್ಯಮಾಪನ ಅಗತ್ಯವಿದ್ದಾಗ, Zod ಅಥವಾ io-ts ನಂತಹ ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.
• ಸ್ಥಿರವಾಗಿರಿ: ಏಕರೂಪದ ಮಟ್ಟದ ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳಲು ನಿಮ್ಮ ಆಯ್ಕೆಮಾಡಿದ ವಿಧಾನವನ್ನು ನಿಮ್ಮ ಕೋಡ್‌ಬೇಸ್‌ನಾದ್ಯಂತ ಸ್ಥಿರವಾಗಿ ಅನ್ವಯಿಸಿ.
• ನಿಮ್ಮ ಪ್ರಕಾರಗಳನ್ನು ದಾಖಲಿಸಿ: ನಿಮ್ಮ ಡೇಟಾದ ನಿರೀಕ್ಷಿತ ಆಕಾರವನ್ನು ಇತರ ಡೆವಲಪರ್‌ಗಳಿಗೆ ತಿಳಿಸಲು ನಿಮ್ಮ ಇಂಟರ್ಫೇಸ್‌ಗಳು ಮತ್ತು ಪ್ರಕಾರಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ದಾಖಲಿಸಿ.
• ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಿ: ನಿಮ್ಮ ಪ್ರಕಾರದ ನಿರ್ಬಂಧಗಳು ನಿರೀಕ್ಷೆಯಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿವೆಯೇ ಮತ್ತು ನಿಮ್ಮ ಕೋಡ್ ಅಮಾನ್ಯ ಡೇಟಾವನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು ಯುನಿಟ್ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯಿರಿ.
• ಪರಸ್ಪರ ವಿನಿಮಯಗಳನ್ನು ಪರಿಗಣಿಸಿ: ಕಟ್ಟುನಿಟ್ಟಾದ ಆಬ್ಜೆಕ್ಟ್ ಆಕಾರ ಹೊಂದಾಣಿಕೆಯನ್ನು ಜಾರಿಗೊಳಿಸುವುದರಿಂದ ನಿಮ್ಮ ಕೋಡ್ ಹೆಚ್ಚು ದೃಢವಾಗಿರುತ್ತದೆ, ಆದರೆ ಇದು ಅಭಿವೃದ್ಧಿ ಸಮಯವನ್ನು ಹೆಚ್ಚಿಸಬಹುದು. ಪ್ರಯೋಜನಗಳನ್ನು ವೆಚ್ಚಗಳ ವಿರುದ್ಧ ತೂಗಿ ನೋಡಿ ಮತ್ತು ನಿಮ್ಮ ಯೋಜನೆಗೆ ಹೆಚ್ಚು ಸೂಕ್ತವಾದ ವಿಧಾನವನ್ನು ಆರಿಸಿ.
• ಹಂತಹಂತವಾದ ಅಳವಡಿಕೆ: ನೀವು ದೊಡ್ಡ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕೋಡ್‌ಬೇಸ್‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದರೆ, ಈ ತಂತ್ರಗಳನ್ನು ಹಂತಹಂತವಾಗಿ ಅಳವಡಿಸಿಕೊಳ್ಳುವುದನ್ನು ಪರಿಗಣಿಸಿ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಅತ್ಯಂತ ನಿರ್ಣಾಯಕ ಭಾಗಗಳಿಂದ ಪ್ರಾರಂಭಿಸಿ.
• ಆಬ್ಜೆಕ್ಟ್ ಆಕಾರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವಾಗ ಟೈಪ್ ಅಲಿಯಾಸ್‌ಗಳಿಗಿಂತ ಇಂಟರ್ಫೇಸ್‌ಗಳಿಗೆ ಆದ್ಯತೆ ನೀಡಿ: ಇಂಟರ್ಫೇಸ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಆದ್ಯತೆ ಪಡೆಯುತ್ತವೆ ಏಕೆಂದರೆ ಅವು ಘೋಷಣೆ ವಿಲೀನವನ್ನು (declaration merging) ಬೆಂಬಲಿಸುತ್ತವೆ, ಇದು ವಿವಿಧ ಫೈಲ್‌ಗಳಲ್ಲಿ ಪ್ರಕಾರಗಳನ್ನು ವಿಸ್ತರಿಸಲು ಉಪಯುಕ್ತವಾಗಬಹುದು.

ನೈಜ-ಪ್ರಪಂಚದ ಉದಾಹರಣೆಗಳು

ನಿಖರ ಪ್ರಕಾರಗಳು ಪ್ರಯೋಜನಕಾರಿಯಾಗಬಹುದಾದ ಕೆಲವು ನೈಜ-ಪ್ರಪಂಚದ ಸನ್ನಿವೇಶಗಳನ್ನು ನೋಡೋಣ:

• API ವಿನಂತಿ ಪೇಲೋಡ್‌ಗಳು: API ಗೆ ಡೇಟಾವನ್ನು ಕಳುಹಿಸುವಾಗ, ಪೇಲೋಡ್ ನಿರೀಕ್ಷಿತ ಸ್ಕೀಮಾಗೆ ಅನುಗುಣವಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ. ನಿಖರ ಪ್ರಕಾರಗಳನ್ನು ಜಾರಿಗೊಳಿಸುವುದರಿಂದ ಅನಿರೀಕ್ಷಿತ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಕಳುಹಿಸುವುದರಿಂದ ಉಂಟಾಗುವ ದೋಷಗಳನ್ನು ತಡೆಯಬಹುದು. ಉದಾಹರಣೆಗೆ, ಅನೇಕ ಪಾವತಿ ಪ್ರಕ್ರಿಯೆ API ಗಳು ಅನಿರೀಕ್ಷಿತ ಡೇಟಾಗೆ ಅತ್ಯಂತ ಸೂಕ್ಷ್ಮವಾಗಿರುತ್ತವೆ.
• ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ಗಳು: ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ, ಮತ್ತು ಮುದ್ರಣದೋಷಗಳು ಸಾಮಾನ್ಯವಾಗಿದೆ. ನಿಖರ ಪ್ರಕಾರಗಳನ್ನು ಬಳಸುವುದರಿಂದ ಈ ಮುದ್ರಣದೋಷಗಳನ್ನು ಮೊದಲೇ ಪತ್ತೆಹಚ್ಚಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ನೀವು ಕ್ಲೌಡ್ ನಿಯೋಜನೆಯಲ್ಲಿ ಸರ್ವರ್ ಸ್ಥಳಗಳನ್ನು ಹೊಂದಿಸುತ್ತಿದ್ದರೆ, ಸ್ಥಳ ಸೆಟ್ಟಿಂಗ್‌ನಲ್ಲಿನ ಮುದ್ರಣದೋಷ (ಉದಾ. eu-west-1 ಬದಲಿಗೆ eu-wet-1) ಮುಂಚಿತವಾಗಿ ಪತ್ತೆಯಾಗದಿದ್ದರೆ ಡೀಬಗ್ ಮಾಡಲು ಅತ್ಯಂತ ಕಷ್ಟಕರವಾಗುತ್ತದೆ.
• ಡೇಟಾ ಪರಿವರ್ತನೆ ಪೈಪ್‌ಲೈನ್‌ಗಳು: ಡೇಟಾವನ್ನು ಒಂದು ಸ್ವರೂಪದಿಂದ ಇನ್ನೊಂದಕ್ಕೆ ಪರಿವರ್ತಿಸುವಾಗ, ಔಟ್‌ಪುಟ್ ಡೇಟಾ ನಿರೀಕ್ಷಿತ ಸ್ಕೀಮಾಗೆ ಅನುಗುಣವಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ಮುಖ್ಯ.
• ಸಂದೇಶ ಸರತಿಗಳು: ಸಂದೇಶ ಸರತಿಯ ಮೂಲಕ ಸಂದೇಶಗಳನ್ನು ಕಳುಹಿಸುವಾಗ, ಸಂದೇಶ ಪೇಲೋಡ್ ಮಾನ್ಯವಾಗಿದೆಯೆ ಮತ್ತು ಸರಿಯಾದ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊಂದಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ಮುಖ್ಯ.

ಉದಾಹರಣೆ: ಅಂತರರಾಷ್ಟ್ರೀಕರಣ (i18n) ಕಾನ್ಫಿಗರೇಶನ್

ಬಹು-ಭಾಷಾ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಅನುವಾದಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತಿರುವುದನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ನಿಮ್ಮ ಬಳಿ ಈ ರೀತಿಯ ಕಾನ್ಫಿಗರೇಶನ್ ಆಬ್ಜೆಕ್ಟ್ ಇರಬಹುದು:

interface Translation {
  greeting: string;
  farewell: string;
}

interface I18nConfig {
  locale: string;
  translations: Translation;
}

const englishConfig: I18nConfig = {
  locale: "en-US",
  translations: {
    greeting: "Hello",
    farewell: "Goodbye"
  }
};


//This will be an issue, as an excess property exists, silently introducing a bug.
const spanishConfig: I18nConfig = {
  locale: "es-ES",
  translations: {
    greeting: "Hola",
    farewell: "Adiós",
    typo: "unintentional translation"
  }
};

//Solution: Using Omit
const spanishConfigCorrect: I18nConfig = {
  locale: "es-ES",
  translations: {
    greeting: "Hola",
    farewell: "Adiós"
  } as Omit & Translation
};

ನಿಖರ ಪ್ರಕಾರಗಳಿಲ್ಲದೆ, ಅನುವಾದ ಕೀಯಲ್ಲಿನ ಮುದ್ರಣದೋಷ (`typo` ಫೀಲ್ಡ್ ಅನ್ನು ಸೇರಿಸಿದಂತೆ) ಗಮನಕ್ಕೆ ಬಾರದೆ ಹೋಗಬಹುದು, ಇದು ಬಳಕೆದಾರ ಇಂಟರ್ಫೇಸ್‌ನಲ್ಲಿ ಅನುವಾದಗಳು ಕಾಣೆಯಾಗಲು ಕಾರಣವಾಗುತ್ತದೆ. ಕಟ್ಟುನಿಟ್ಟಾದ ಆಬ್ಜೆಕ್ಟ್ ಆಕಾರ ಹೊಂದಾಣಿಕೆಯನ್ನು ಜಾರಿಗೊಳಿಸುವ ಮೂಲಕ, ನೀವು ಈ ದೋಷಗಳನ್ನು ಅಭಿವೃದ್ಧಿಯ ಸಮಯದಲ್ಲಿಯೇ ಪತ್ತೆಹಚ್ಚಬಹುದು ಮತ್ತು ಅವು ಉತ್ಪಾದನೆಯನ್ನು ತಲುಪುವುದನ್ನು ತಡೆಯಬಹುದು.

ತೀರ್ಮಾನ

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಅಂತರ್ನಿರ್ಮಿತ "ನಿಖರ ಪ್ರಕಾರಗಳು" ಇಲ್ಲದಿದ್ದರೂ, ನೀವು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ವೈಶಿಷ್ಟ್ಯಗಳು ಮತ್ತು `Omit` ಜೊತೆಗೆ ಟೈಪ್ ಅಸರ್ಷನ್‌ಗಳು, ಫ್ಯಾಕ್ಟರಿ ಫಂಕ್ಷನ್‌ಗಳು, ಟೈಪ್ ಗಾರ್ಡ್‌ಗಳು, `Readonly`, `as const`, ಮತ್ತು Zod ಮತ್ತು io-ts ನಂತಹ ಬಾಹ್ಯ ಲೈಬ್ರರಿಗಳ ಸಂಯೋಜನೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಇದೇ ರೀತಿಯ ಫಲಿತಾಂಶಗಳನ್ನು ಸಾಧಿಸಬಹುದು. ಕಟ್ಟುನಿಟ್ಟಾದ ಆಬ್ಜೆಕ್ಟ್ ಆಕಾರ ಹೊಂದಾಣಿಕೆಯನ್ನು ಜಾರಿಗೊಳಿಸುವ ಮೂಲಕ, ನಿಮ್ಮ ಕೋಡ್‌ನ ದೃಢತೆಯನ್ನು ಸುಧಾರಿಸಬಹುದು, ಸಾಮಾನ್ಯ ದೋಷಗಳನ್ನು ತಡೆಯಬಹುದು ಮತ್ತು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಹೆಚ್ಚು ವಿಶ್ವಾಸಾರ್ಹವಾಗಿಸಬಹುದು. ನಿಮ್ಮ ಅಗತ್ಯಗಳಿಗೆ ಸೂಕ್ತವಾದ ವಿಧಾನವನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಮತ್ತು ಅದನ್ನು ನಿಮ್ಮ ಕೋಡ್‌ಬೇಸ್‌ನಾದ್ಯಂತ ಸ್ಥಿರವಾಗಿ ಅನ್ವಯಿಸಲು ಮರೆಯದಿರಿ. ಈ ವಿಧಾನಗಳನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಪರಿಗಣಿಸುವ ಮೂಲಕ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಪ್ರಕಾರಗಳ ಮೇಲೆ ಹೆಚ್ಚಿನ ನಿಯಂತ್ರಣವನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಮತ್ತು ದೀರ್ಘಾವಧಿಯ ನಿರ್ವಹಣೆಯನ್ನು ಹೆಚ್ಚಿಸಬಹುದು.